#include<iostream>
using namespace std;

/*运算符重载函数（成员函数重载）
1.给运算符重新定义一个新功能
*2.解析:左操作数（c1）作为当前对象去调用函数
		右操作数（c2）作为函数的参数
	    函数名：operator + 运算符
	e.g c1.operator+ (c2) {}
        (给“+”重新定义一个新功能)
3.系统会提供一个默认的赋值运算符("=")重载函数
4.const &
5.注意：
    (1).运算符重载函数要在类内进行定义；
	(2).第一个操作数必须是对象，不能是其他类型。
*/

//实现复数的加法运算
/*
class Com
{
	int shi;
	int xv;
public:
	Com(int s = 0, int x = 0)
	{
		shi = s;
		xv = x;
	}
	//返回类型 operator + 运算符 (参数) {}
	Com operator+(const Com &c)
	{
		Com sum; //可以不传参，因为构造函数有默认参数
		sum.shi = shi + c.shi;
		sum.xv = xv + c.xv;
		return sum;
	}
	//如果赋值表达式为“c3=c1”,赋值运算符重载函数的参数要写为引用，因为c1是变量，要得到它的成员值需要找到它的地址；
	//如果赋值表达式为“c3=c1+c2”,赋值运算重载函数的参数不能写为引用，因为c1+c2是 operator+() 函数的返回值sum，
	//该返回值是一个常量，而不是变量，不需要取地址找它的成员值。
	void operator=(Com s)//系统自带，可以不写
	{
		shi = s.shi;
		xv = s.xv;
	}
	void show()
	{
		cout<<shi<<"+"<<xv<<"i"<<endl;
	}
};

int main()
{
	Com c1(4, 5), c2(2, 3), c3, c4;
	c3 = c1 + c2; //编译器会将 c1 + c2 转化为右侧的内容 --->  c1.operator+ (c2);
				  //编译器会将 c3 = c1 + c2 转化为右侧的内容 ---> c3.operator= (c1 + c2);
	cout<<"c3 = ";
	c3.show();
	
	c4 = c2 + 7;//此处的 7 自动转化为函数中的 c.shi 
	cout<<"c4 = ";
	c4.show();
	
	//7+c1; 错误：第一个操作数必须是对象。
	
	return 0;
}
*/

//练习：1.实现 c4=c1-c2  2.实现c1>c2  (c1和c2是复数)
/*
class com
{
	int shi;
	int xv;
public:
	com(int s = 0, int x = 0)
	{
		shi = s;
		xv = x;
	}
	com operator-(const com c)
	{
		com sub;
		sub.shi = shi - c.shi;
		sub.xv = xv - c.xv;
		return sub;
	}
	
	int operator>(const com c)
	{
		if(shi > c.shi)
			return 1;
		else if(shi == c.shi)
		{
			if(xv > c.xv)
				return 1;
			else if(xv == c.xv)
			{	
				cout<<"两数相等"<<endl;
				return 0;
			}
			else
				return 0;
		}
		else
			return 0;
	}
	void show()
	{
		cout<<shi<<"+"<<xv<<"i"<<endl;
	}
};

int main()
{
	com c1(4, 3), c2(4, 3), c3;
	c3 = c1 - c2; // --->  c1.operator-(c2);
	cout<<"c3 = ";
	c3.show();
	
	int a = 0;
	a = c1 > c2; // --->  c1.operator>(c2);
	cout<<"a = "<<a<<endl;
	return 0;
}*/
